package almacenes.controlador.administrar;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.faces.FacesException;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.faces.model.SelectItem;
import javax.servlet.http.HttpSession;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import almacenes.controlador.estado.Estado;
import almacenes.modelo.entidad.Departamento;
import almacenes.modelo.entidad.ParametroDet;
import almacenes.modelo.entidad.RolMae;
import almacenes.modelo.entidad.RolesUsuarioRel;
import almacenes.modelo.entidad.UsuarioMae;
import almacenes.modelo.excepcion.ExcepcionGeneral;
import almacenes.modelo.service.DepartamentoService;
import almacenes.modelo.service.ParametroService;
import almacenes.modelo.service.RolService;
import almacenes.modelo.service.UsuarioService;
import almacenes.modelo.service.impl.DepartamentoServiceImpl;
import almacenes.modelo.service.impl.ParametroServiceImpl;
import almacenes.modelo.service.impl.RolServiceImpl;
import almacenes.modelo.service.impl.UsuarioServiceImpl;
import almacenes.modelo.util.Utilitarios;

/*@ManagedBean(name = "usuarioMB")
@SessionScoped*/
public class UsuarioMB implements Serializable {

	private static final long serialVersionUID = 1L;

	protected final Log logger = LogFactory.getLog(this.getClass());

	private String sMensaje;
	
	private UsuarioMae objUsuario;
	private List<RolMae> lstRoles = new ArrayList<RolMae>();
	private List<Departamento> lstDepartamento = new ArrayList<Departamento>();
	private List<UsuarioMae> lstUsuarios;
	private List<UsuarioMae> lstUsuariosBus;
	private List<UsuarioMae> lstUsuariosGM = new ArrayList<UsuarioMae>();
	private List<RolesUsuarioRel> lstRolesUser;
		
	private UsuarioService objUsuarioService;
	private ParametroService objParametroService;
	private RolService objRolService;
	private DepartamentoService objService;
	
	private List<ParametroDet> lstEstadosGenerales;
	
	//id de los combos
	private Integer iIdEstadoUser;
	private Integer iIdRolUser;
	private Integer iIdDepartamentoUser;
	private Integer iIdUsuarioMayor;
	
	//Cantidad de valores en tablas
	private int iCanRolesEditUser;
	private int iCanHijosxGenMayor;
	private int iCanListaUser;
	
	private String nombreUserBBVA;
	
	private boolean bflagCombo = true;
	
	public UsuarioMB() {
		System.out.println("******* ENTRO AL CONSTRUCTOR *******");
		objUsuario = new UsuarioMae();
		lstUsuarios = new ArrayList<UsuarioMae>();
		lstUsuariosBus = new ArrayList<UsuarioMae>();
		lstEstadosGenerales = new ArrayList<ParametroDet>();

	}
	
	public void guardaIdRolUser(){
		
		putObjectInSession("iIdRolUser", iIdRolUser);
		System.out.println("guarde en sesion el id Rol: "+iIdRolUser);
		
	}
	
	public void validaRolUser(){
		System.out.println("ENTRO AL METODO VALIDARUSER");
		
		try {
			Integer idRol = (Integer) getObjectInSession("iIdRolUser");
			System.out.println("se casteooooo: "+idRol);
			if(idRol==7 && iIdDepartamentoUser !=0){
				
				lstUsuariosGM = objUsuarioService.getUsuariosGM(iIdDepartamentoUser);
				if(lstUsuariosGM.size()>0)
					bflagCombo = false;
				else{
					System.out.println("ENTRO AL ELSE DE GENERADOR MAYOR");
					bflagCombo=true;
					Utilitarios.mensajeInfo("", "No existen Generadores Mayores, elija otro rol");
				}
					
			}
			
			
			
			//removeObjectInSession("iIdRolUser");
			
			
		} catch (ExcepcionGeneral e) {
			String sMensaje = "No se puedo inicializar lstUsuariosBus";
			this.logger.error(e.getMessage());
			throw new FacesException(sMensaje, e);
		}
		
		
		//removeObjectInSession("iIdRolUser");
		System.out.println("PASO CON EXITOOOO");
	}
	
	public static void putObjectInSession(String value, Object var) {
		  ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();
		  HttpSession session = (HttpSession) context.getSession(true);
		  session.setAttribute(value, var);
	}
	
	public static Object getObjectInSession(String value) {
		  ExternalContext context = FacesContext.getCurrentInstance()
		    .getExternalContext();
		  HttpSession sessionhttp = (HttpSession) context.getSession(true);
		  return (Object) sessionhttp.getAttribute(value);
	}
	
	 public static void removeObjectInSession(String value) {
		  ExternalContext context = FacesContext.getCurrentInstance()
		    .getExternalContext();
		  HttpSession session = (HttpSession) context.getSession(false);
		  session.removeAttribute(value);
		  session.invalidate();
     }
	
	
	public void editarUsuarioAdministrador(){

		setObjUsuario(new UsuarioMae());
		
		Map<String, String> paramMap = FacesContext.getCurrentInstance()
				.getExternalContext().getRequestParameterMap();

		int codUsu = Integer.parseInt(paramMap.get("codUsu"));
		System.out.println("ME LLEGO EL CODIGO DE USUARIO EN EL PARAMETRO: "+codUsu);
		
		putObjectInSession("idUserEdit",codUsu);
		
		UsuarioMae objUsuEnviado = new UsuarioMae();
		objUsuEnviado.setIdUsuario(codUsu);

		try {
			
			objUsuario = objUsuarioService.getUsuarioBBVA(objUsuEnviado);
			System.out.println("ME LLEGO EL USUARIO: "+objUsuario.getNombreUsuario());
			
			iCanRolesEditUser = listarRolesUserBBVA(codUsu);
			iCanHijosxGenMayor = listaHijosxGenMayor(codUsu);
			
		} catch (ExcepcionGeneral ex) {
			String sMensaje = "No se puedo inicializar editarUsuarioAdministrador";
			this.logger.error(ex.getMessage());
			throw new FacesException(sMensaje, ex);
		}
		
		//return "usuario";
	}
	
	public void insertarRolUsuarioBBVA(ActionEvent e){
		
		Integer idUserEdit = (Integer) getObjectInSession("idUserEdit");
		System.out.println("ID_USUARIO EDITAR: "+idUserEdit);
		System.out.println("ID_ROL: "+iIdRolUser);
		System.out.println("ID_DEPARTAMENTO: "+iIdDepartamentoUser);
		System.out.println("ID_USUARIOMAYOR: "+iIdUsuarioMayor);
		String sMensaje = "";
		
		try {
			
			if(iIdRolUser == 0){
				Utilitarios.mensajeError("", "Debe seleccionar un rol");
			}
			else if(iIdDepartamentoUser == 0){
				Utilitarios.mensajeError("", "Debe seleccionar un departamento");
			}
			else if(iIdUsuarioMayor != null){
				Utilitarios.mensajeError("", "Debe elegir un usuario Mayor");
			}
			else{
			
				sMensaje = objUsuarioService.insertaRolUserBBVA(idUserEdit, iIdRolUser, iIdDepartamentoUser, iIdUsuarioMayor);
				setLstRolesUser(new ArrayList<RolesUsuarioRel>());
				setLstRolesUser(objUsuarioService.getListaRolesUser(idUserEdit));
				Utilitarios.mensaje("", sMensaje);				
			
			}
		} catch (ExcepcionGeneral ex) {
			sMensaje = "No se puedo inicializar editarUsuarioAdministrador";
			this.logger.error(ex.getMessage());
			throw new FacesException(sMensaje, ex);
		}
		
		
	}
	
	public void eliminarUserBBVA(ActionEvent e){
		
		String sMensaje = "";
		Map<String, String> paramMap = FacesContext.getCurrentInstance()
				.getExternalContext().getRequestParameterMap();

		int codUsu = Integer.parseInt(paramMap.get("codUser"));
		String codBBVA = paramMap.get("codBBVA");
		System.out.println("ME LLEGO EL CODIGO DE USUARIO A ELIMINAR: "+codUsu);
		System.out.println("ME LLEGO EL CODIGO DE USUARIO BBVA: "+codBBVA);
		UsuarioMae objElimina = new UsuarioMae();
		objElimina.setIdUsuario(codUsu);
		objElimina.setCodusuBbva(codBBVA);
		
		try{
			
			sMensaje = objUsuarioService.eliminarUserBBVA(objElimina);
			
			setLstUsuarios(new ArrayList<UsuarioMae>());
			setLstUsuarios(objUsuarioService.getListaUsuarios());
			
			Utilitarios.mensaje("", sMensaje);
			
		} catch (ExcepcionGeneral ex) {
			sMensaje = "No se puedo inicializar eliminarUserBBVA";
			this.logger.error(ex.getMessage());
			throw new FacesException(sMensaje, ex);
		}

		
	}
	
	public void updateUsuarioBBVA(ActionEvent e){
		
		String sMensaje = "";
		Integer idUserEdit = (Integer) getObjectInSession("idUserEdit");
		UsuarioMae objUserUpdate = new UsuarioMae();
		objUserUpdate.setIdUsuario(idUserEdit);
		objUserUpdate.setIdEstado(iIdEstadoUser);
		objUserUpdate.setCodusuBbva(objUsuario.getCodusuBbva());
		objUserUpdate.setNombreUsuario(objUsuario.getNombreUsuario());
		
		try {
			
			sMensaje = objUsuarioService.updateUserBBVA(objUserUpdate);
			
			Utilitarios.mensaje("", sMensaje);
			
		} catch (ExcepcionGeneral e1) {
			sMensaje = "No se puedo inicializar updateUsuarioBBVA";
			this.logger.error(e1.getMessage());
			throw new FacesException(sMensaje, e1);
		}
		
		//removeObjectInSession("idUserEdit");
		
	}
	
	public void removeRolUserEdit(){
		
		String sMensaje = "";
		Map<String, String> paramMap = FacesContext.getCurrentInstance()
				.getExternalContext().getRequestParameterMap();
		int iCodRol_usu = Integer.parseInt(paramMap.get("codUsuarioRol"));
		//int iCanRoles = Integer.parseInt(paramMap.get("canRoles"));
		RolesUsuarioRel objRolesUsu = new RolesUsuarioRel();
		objRolesUsu.setIdRolUsuario(iCodRol_usu);

		this.logger.info("METODO removeRolUserEdit");
		
		try {
			
			if(iCanRolesEditUser <2){
				
				Utilitarios.mensajeError("", "Ingrese otro rol, para podre eliminar");
			}
			else{
			
				Integer idUserEdit = (Integer) getObjectInSession("idUserEdit");
				sMensaje = objUsuarioService.removeRolUser(objRolesUsu);
				iCanRolesEditUser = listarRolesUserBBVA(idUserEdit);
				Utilitarios.mensaje("", sMensaje);
			}
		} catch (ExcepcionGeneral e1) {
			sMensaje = "No se puedo inicializar removeRolUserEdit";
			this.logger.error("ERROR EN REMOVEROL: "+e1.getMessage());
			throw new FacesException(sMensaje, e1);
		}
		
		
	}
	
	public String obtenerUsuarioBBVA(){
	
		String sUser = "";
	
		try {
			
			if(objUsuario.getCodusuBbva().length()==7){
				sUser = objUsuarioService.obtenerUsuarioBBVA(objUsuario.getCodusuBbva());
		
				if(sUser !="")
					objUsuario.setNombreUsuario(sUser);
				else
					Utilitarios.mensajeError("", "Usuario ya existe");
			}
			else
				Utilitarios.mensajeError("", "El codigo es un alfanumerico de 7 cifras");

		} catch (ExcepcionGeneral e) {
			String sMensaje = "No se puedo inicializar obtenerUsuarioBBVA";
			this.logger.error("ERROR: "+e.getMessage());
			throw new FacesException(sMensaje, e);
		}
		
		return "usuario";
	}
	
	public void registrarUsuarioBBVA(ActionEvent e){
		
		
		this.logger.info("INFO: registrarUsuarioBBVA");
		
		System.out.println("ENVIARE LOS PARAMETROS");
		System.out.println("NOMBRE_USUARIO: "+objUsuario.getNombreUsuario());
		System.out.println("COD_UDUARIO_BBVA: "+objUsuario.getCodusuBbva());
		System.out.println("ID_USUARIO_MAYOR: "+iIdUsuarioMayor);
		System.out.println("ID_ROL: "+iIdRolUser);
		System.out.println("ID_DEPARTAMENTO: "+iIdDepartamentoUser);
		System.out.println("ESTOI A PUNTO DE ENVIAR LOS VALORES");
		try {
			sMensaje = objUsuarioService.insertUserBBVA(objUsuario, iIdRolUser, iIdDepartamentoUser, iIdUsuarioMayor);
			Utilitarios.mensaje(sMensaje, "");
			setObjUsuario(new UsuarioMae());
			//lstUsuarios = objUsuarioService.getListaUsuarios();
			iCanListaUser = obtenerListaUsuarios();
			
		} catch (ExcepcionGeneral ex) {
			String sMensaje = "No se puedo inicializar registrarUsuarioBBVA";
			this.logger.error("ERROR: "+ex.getMessage());
			throw new FacesException(sMensaje, ex);
		}

	}
	
	

	public void buscarUsuarios(){
		
		try {
			
			System.out.println("ENVIARE LOS PARAMETROS");
			System.out.println("NOMBRE_USUARIO: "+objUsuario.getNombreUsuario());
			System.out.println("COD_UDUARIO_BBVA: "+objUsuario.getCodusuBbva());
			System.out.println("ID_ESTADO: "+iIdEstadoUser);
			System.out.println("ID_ROL: "+iIdRolUser);
			System.out.println("ID_DEPARTAMENTO: "+iIdDepartamentoUser);

			lstUsuarios = objUsuarioService.buscarUsuarios(objUsuario, iIdEstadoUser, iIdRolUser, iIdDepartamentoUser);
			iCanListaUser = lstUsuarios.size();
			
		} catch (ExcepcionGeneral e) {
			String sMensaje = "No se puedo inicializar lstUsuariosBus";
			this.logger.error(e.getMessage());
			throw new FacesException(sMensaje, e);
		}
	
	}
	
	//Metodos para listar los comboBox
	
	public int listaHijosxGenMayor(Integer iIdUser){
		objUsuarioService = new UsuarioServiceImpl();
		int can =0;
		try {
			lstUsuariosGM = objUsuarioService
					.getHijosxGenMayor(iIdUser);
			
			can = lstUsuariosGM.size();
		} catch (ExcepcionGeneral ex) {
			String sMensaje = "No se puedo inicializar listaHijosxGenMayor";
			this.logger.error("ERROR: No se puedo inicializar listaHijosxGenMayor", ex);
			throw new FacesException(sMensaje, ex);
		}
		return can;
		
	}
	
	public void obtenerEstadosUsuarios() {
		objParametroService = new ParametroServiceImpl();
		try {
			lstEstadosGenerales = objParametroService
					.obtenerTiposDeEstados(Estado.GENERAL);
		} catch (ExcepcionGeneral ex) {
			String sMensaje = "No se puedo inicializar lstEstados";
			this.logger.error("No se puedo inicializar lstEstados", ex);
			throw new FacesException(sMensaje, ex);
		}
	}

	public int obtenerListaUsuarios() {
		
		int can =0;
		objUsuarioService = new UsuarioServiceImpl();
		try {
			lstUsuarios = objUsuarioService.getListaUsuarios();
			can = lstUsuarios.size();
		} catch (ExcepcionGeneral e) {
			String sMensaje = "No se puedo inicializar lstUsuarios";
			this.logger.error("No se puedo inicializar lstUsuarios", e);
			throw new FacesException(sMensaje, e);
		}
		
		return can;

	}
	
	public int listarRolesUserBBVA(int iIdUsuario){
		
		int can = 0;
		
		try {
			lstRolesUser = new ArrayList<RolesUsuarioRel>();
			lstRolesUser = objUsuarioService.getListaRolesUser(iIdUsuario);
			can = lstRolesUser.size();
		} catch (ExcepcionGeneral e) {
			String sMensaje = "No se puedo inicializar lstUsuarios";
			this.logger.error("No se puedo inicializar lstUsuarios", e);
			throw new FacesException(sMensaje, e);
		}
		
		return can;
	}

	public void obtenerListaRoles() {

		objRolService = new RolServiceImpl();
		try {
			lstRoles = objRolService.getListaRoles();
		} catch (ExcepcionGeneral e) {
			String sMensaje = "No se puedo inicializar lstRoles";
			this.logger.error("No se puedo inicializar lstRoles", e);
			throw new FacesException(sMensaje, e);
		}

	}
	
	public void obtenerListaDepartamentos() {

		objService = new DepartamentoServiceImpl();
		try {
			lstDepartamento = objService.getListaDepartamento();
		} catch (ExcepcionGeneral e) {
			String sMensaje = "No se puedo inicializar lstRoles";
			this.logger.error("No se puedo inicializar lstRoles", e);
			throw new FacesException(sMensaje, e);
		}

	}
	
	public List<SelectItem> getListaRoles() {
		List<SelectItem> l = new ArrayList<SelectItem>();
		try {
			for (RolMae r : lstRoles) {
				l.add(new SelectItem(r.getIdRol(), r.getDescripcion()));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

		return l;
	}

	public void actionEOpenRegister(ActionEvent a) {
		try {
			setObjUsuario(new UsuarioMae());
			//removeObjectInSession("iIdRolUser");

		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public List<RolMae> getLstRoles() {
		if (lstRoles.isEmpty()) {
			obtenerListaRoles();
		}
		return lstRoles;
	}

	public void setLstRoles(List<RolMae> lstRoles) {
		this.lstRoles = lstRoles;
	}

	public UsuarioMae getObjUsuario() {
		return objUsuario;
	}

	public void setObjUsuario(UsuarioMae objUsuario) {
		this.objUsuario = objUsuario;
	}

	public List<Departamento> getLstDepartamento() {
		if (lstDepartamento.isEmpty()) {
			obtenerListaDepartamentos();
		}
		return lstDepartamento;
	}

	public void setLstDepartamento(List<Departamento> lstDepartamento) {
		this.lstDepartamento = lstDepartamento;
	}

	public List<UsuarioMae> getLstUsuarios() {
		if (lstUsuarios.isEmpty()) {
			iCanListaUser=obtenerListaUsuarios();
		}
		return lstUsuarios;
	}

	public void setLstUsuarios(List<UsuarioMae> lstUsuarios) {
		this.lstUsuarios = lstUsuarios;
	}

	public Integer getiIdEstadoUser() {
		return iIdEstadoUser;
	}

	public void setiIdEstadoUser(Integer iIdEstadoUser) {
		this.iIdEstadoUser = iIdEstadoUser;
	}

	public List<ParametroDet> getLstEstadosGenerales() {
		if (lstEstadosGenerales.isEmpty()) {
			obtenerEstadosUsuarios();
		}
		return lstEstadosGenerales;
	}

	public void setLstEstadosGenerales(List<ParametroDet> lstEstadosGenerales) {
		this.lstEstadosGenerales = lstEstadosGenerales;
	}

	public Integer getiIdRolUser() {
		return iIdRolUser;
	}

	public void setiIdRolUser(Integer iIdRolUser) {
		this.iIdRolUser = iIdRolUser;
	}


	public List<UsuarioMae> getLstUsuariosBus() {
		if (lstUsuariosBus.isEmpty()) {
			obtenerEstadosUsuarios();
		}
		return lstUsuariosBus;
	}

	public void setLstUsuariosBus(List<UsuarioMae> lstUsuariosBus) {
		this.lstUsuariosBus = lstUsuariosBus;
	}

	public Integer getiIdDepartamentoUser() {
		return iIdDepartamentoUser;
	}

	public void setiIdDepartamentoUser(Integer iIdDepartamentoUser) {
		this.iIdDepartamentoUser = iIdDepartamentoUser;
	}

	public boolean isBflagCombo() {
		return bflagCombo;
	}

	public void setBflagCombo(boolean bflagCombo) {
		this.bflagCombo = bflagCombo;
	}

	public String getNombreUserBBVA() {
		return nombreUserBBVA;
	}

	public void setNombreUserBBVA(String nombreUserBBVA) {
		this.nombreUserBBVA = nombreUserBBVA;
	}

	public List<UsuarioMae> getLstUsuariosGM() {
		return lstUsuariosGM;
	}

	public void setLstUsuariosGM(List<UsuarioMae> lstUsuariosGM) {
		this.lstUsuariosGM = lstUsuariosGM;
	}

	public String getsMensaje() {
		return sMensaje;
	}

	public void setsMensaje(String sMensaje) {
		this.sMensaje = sMensaje;
	}

	public Integer getiIdUsuarioMayor() {
		return iIdUsuarioMayor;
	}

	public void setiIdUsuarioMayor(Integer iIdUsuarioMayor) {
		this.iIdUsuarioMayor = iIdUsuarioMayor;
	}

	public List<RolesUsuarioRel> getLstRolesUser() {
		return lstRolesUser;
	}

	public void setLstRolesUser(List<RolesUsuarioRel> lstRolesUser) {
		this.lstRolesUser = lstRolesUser;
	}

	public int getiCanRolesEditUser() {
		return iCanRolesEditUser;
	}

	public void setiCanRolesEditUser(int iCanRolesEditUser) {
		this.iCanRolesEditUser = iCanRolesEditUser;
	}

	public int getiCanHijosxGenMayor() {
		return iCanHijosxGenMayor;
	}

	public void setiCanHijosxGenMayor(int iCanHijosxGenMayor) {
		this.iCanHijosxGenMayor = iCanHijosxGenMayor;
	}

	public int getiCanListaUser() {
		return iCanListaUser;
	}

	public void setiCanListaUser(int iCanListaUser) {
		this.iCanListaUser = iCanListaUser;
	}



}
